home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  16.1 KB  |  621 lines
  1. /*
  2.  *    @(#) menus.c 12.1 95/05/09 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S003, 15-Sep-93, rickra
  22.  *    Create the function create_window_option_menu_bar.
  23.  *
  24.  * S002, 27-May-93, rickra
  25.  *     Took out all "seperate window" entries. This is now taken care
  26.  *    of in xsw.c as toggle button callbacks.....
  27.  *
  28.  * S001, 01-Jan-93, rickra
  29.  *     Added ascending/descending of PSMEM , PSIO, PSCPU
  30.  *
  31.  * S000, 30-Sep-92, rickra
  32.  *     Added copyright and modification history
  33.  */
  34. #include <stdio.h>
  35. #include <X11/Xlib.h>
  36. #include <X11/Xutil.h>
  37. #include <X11/Intrinsic.h>
  38. #include <X11/Shell.h>
  39. #include <X11/StringDefs.h>
  40. #include <Xm/Xm.h>
  41. #include <Xm/MainW.h>
  42. #include <Xm/DrawingA.h>
  43. #include <Xm/Separator.h>
  44. #include <Xm/ToggleB.h>
  45. #include <Xm/CascadeB.h>
  46. #include <Xm/RowColumn.h>
  47. #include <Xm/Label.h>
  48.  
  49. #include "include/menus.h"
  50. #include "include/buttons.h"
  51. #include "include/resources.h"
  52. #include "include/xprocs.h"
  53. #include "include/sepwin.h"
  54.  
  55. extern XColor   colorAuxButtonOnForeground;;
  56. extern XColor   colorAuxButtonOnBackground;;
  57. extern XColor   colorAuxButtonOffForeground;;
  58. extern XColor   colorAuxButtonOffBackground;;
  59.  
  60. extern unsigned long foreground;
  61.  
  62. extern Widget   sub_menu_state_list[Max_sub_menu_buttons];
  63.  
  64. extern char     connect_to_server_string[];
  65. extern char     disconnect_to_server_string[];
  66. extern char     quit_string[];
  67.  
  68.  
  69. extern char     font_Default_string[];
  70. extern char     font_6x10_string[];
  71. extern char     font_6x12_string[];
  72. extern char     font_6x13_string[];
  73. extern char     font_8x13_string[];
  74. extern char     font_9x15_string[];
  75. extern char     font_ibm10x20_string[];
  76.  
  77. extern char     general_help_string[];
  78. extern char     option_help_string[];
  79. extern char     known_help_string[];
  80.  
  81. extern char     increase_string1[];
  82. extern char     decrease_string1[];
  83. extern char     popup_string1[];
  84. extern char     increase_string2[];
  85. extern char     decrease_string2[];
  86. extern char     popup_string2[];
  87. extern char     increase_string3[];
  88. extern char     decrease_string3[];
  89. extern char     popup_string3[];
  90.  
  91.  
  92.  
  93. char            file_string[] = "File";
  94.  
  95. void
  96. xs_create_menu_buttons (title, menu, menulist, nitems, dynamic_callback_data,
  97.             callback_data)
  98.      char           *title;
  99.      Widget          menu;
  100.      xs_menu_struct *menulist;
  101.      int             nitems;
  102.      int             dynamic_callback_data;
  103.      struct ps_button_callback_struct *callback_data;
  104.  
  105. {
  106.  
  107.   int             i;
  108.   WidgetList      buttons;
  109.   int             separators = 0;
  110.   char           *help_string = "Help";
  111.   Widget          help_widget;
  112.  
  113.   Arg             args[32];
  114.   int             argcount = 0;
  115.  
  116.   /*
  117.    * Allocate a widget list to hold all button widgets.
  118.    */
  119.  
  120.   buttons = (WidgetList) XtMalloc (nitems * sizeof (Widget));
  121.  
  122.   /*
  123.    * If a title is given, create Label and Separator widgets.
  124.    */
  125.  
  126.   if (title)
  127.     {
  128.  
  129.       argcount = 0;
  130.  
  131.       XtCreateManagedWidget (title, xmLabelWidgetClass, menu,
  132.                  args, argcount);
  133.  
  134.       XtCreateManagedWidget ("separator", xmSeparatorWidgetClass,
  135.                  menu, args, argcount);
  136.     }
  137.  
  138.   /*
  139.    * Create an entry for each item in the menu.
  140.    */
  141.  
  142.   for (i = 0; i < nitems; i++)
  143.     {
  144.  
  145.       /*
  146.        * A NULL name represents a separator.
  147.        */
  148.  
  149.       if (menulist[i].name == NULL)
  150.     {
  151.       XtCreateManagedWidget ("separator",
  152.                  xmSeparatorWidgetClass,
  153.                  menu, args, argcount);
  154.       separators++;        /* Count how many entries aren't buttons */
  155.     }
  156.       /*
  157.        * If there is a name and a callback, create a "normal" menu entry and
  158.        * register the callback function.
  159.        */
  160.       else if (menulist[i].func)
  161.     {
  162.       argcount = 0;
  163.       XtSetArg (args[argcount], XmNmnemonic,
  164.             (XtArgVal) menulist[i].key_name);
  165.       argcount++;
  166.  
  167.       buttons[i - separators] = XtCreateWidget (menulist[i].name,
  168.                           xmToggleButtonWidgetClass,
  169.                             menu, args, argcount);
  170.  
  171.       XtAddCallback (buttons[i - separators], XmNvalueChangedCallback,
  172.              menulist[i].func, menulist[i].data);
  173.  
  174.       if ((strcmp (menulist[i].name, connect_to_server_string) == 0))
  175.         {
  176.           sub_menu_state_list[BUTTON_connect_server] = buttons[i - separators];
  177.         }
  178.       if ((strcmp (menulist[i].name, disconnect_to_server_string) == 0))
  179.         {
  180.           sub_menu_state_list[BUTTON_disconnect_server] = buttons[i - separators];
  181.         }
  182.  
  183.  
  184.       else if ((strcmp (menulist[i].name, font_Default_string) == 0))
  185.         {
  186.           sub_menu_state_list[BUTTON_Default] = buttons[i - separators];
  187.         }
  188.       else if ((strcmp (menulist[i].name, font_6x10_string) == 0))
  189.         {
  190.           sub_menu_state_list[BUTTON_6x10] = buttons[i - separators];
  191.         }
  192.       else if ((strcmp (menulist[i].name, font_6x12_string) == 0))
  193.         {
  194.           sub_menu_state_list[BUTTON_6x12] = buttons[i - separators];
  195.         }
  196.       else if ((strcmp (menulist[i].name, font_6x13_string) == 0))
  197.         {
  198.           sub_menu_state_list[BUTTON_6x13] = buttons[i - separators];
  199.         }
  200.       else if ((strcmp (menulist[i].name, font_8x13_string) == 0))
  201.         {
  202.           sub_menu_state_list[BUTTON_8x13] = buttons[i - separators];
  203.         }
  204.       else if ((strcmp (menulist[i].name, font_9x15_string) == 0))
  205.         {
  206.           sub_menu_state_list[BUTTON_9x15] = buttons[i - separators];
  207.         }
  208.       else if ((strcmp (menulist[i].name, font_ibm10x20_string) == 0))
  209.         {
  210.           sub_menu_state_list[BUTTON_ibm10x20] = buttons[i - separators];
  211.         }
  212.       else if ((strcmp (menulist[i].name, general_help_string) == 0))
  213.         {
  214.           sub_menu_state_list[BUTTON_general_help] = buttons[i - separators];
  215.         }
  216.       else if ((strcmp (menulist[i].name, option_help_string) == 0))
  217.         {
  218.           sub_menu_state_list[BUTTON_options_help] = buttons[i - separators];
  219.         }
  220.       else if ((strcmp (menulist[i].name, known_help_string) == 0))
  221.         {
  222.           sub_menu_state_list[BUTTON_known_help] = buttons[i - separators];
  223.         }
  224.  
  225.  
  226.       else if ((strcmp (menulist[i].name, increase_string1) == 0))
  227.         {
  228.           sub_menu_state_list[BUTTON_button_1_increase] = buttons[i - separators];
  229.         }
  230.       else if ((strcmp (menulist[i].name, decrease_string1) == 0))
  231.         {
  232.           sub_menu_state_list[BUTTON_button_1_decrease] = buttons[i - separators];
  233.         }
  234.       else if ((strcmp (menulist[i].name, popup_string1) == 0))
  235.         {
  236.           sub_menu_state_list[BUTTON_button_1_popup] = buttons[i - separators];
  237.         }
  238.       else if ((strcmp (menulist[i].name, increase_string2) == 0))
  239.         {
  240.           sub_menu_state_list[BUTTON_button_2_increase] = buttons[i - separators];
  241.         }
  242.       else if ((strcmp (menulist[i].name, decrease_string2) == 0))
  243.         {
  244.           sub_menu_state_list[BUTTON_button_2_decrease] = buttons[i - separators];
  245.         }
  246.       else if ((strcmp (menulist[i].name, popup_string2) == 0))
  247.         {
  248.           sub_menu_state_list[BUTTON_button_2_popup] = buttons[i - separators];
  249.         }
  250.       else if ((strcmp (menulist[i].name, increase_string3) == 0))
  251.         {
  252.           sub_menu_state_list[BUTTON_button_3_increase] = buttons[i - separators];
  253.         }
  254.       else if ((strcmp (menulist[i].name, decrease_string3) == 0))
  255.         {
  256.           sub_menu_state_list[BUTTON_button_3_decrease] = buttons[i - separators];
  257.         }
  258.       else if ((strcmp (menulist[i].name, popup_string3) == 0))
  259.         {
  260.           sub_menu_state_list[BUTTON_button_3_popup] = buttons[i - separators];
  261.         }
  262.  
  263.  
  264.  
  265.     }
  266.  
  267.       /*
  268.        * If there is a name, but no callback function, the entry must be a
  269.        * label, unless there is a submenu.
  270.        */
  271.       else if (!menulist[i].sub_menu)
  272.     {
  273.       argcount = 0;
  274.       XtSetArg (args[argcount], XmNmnemonic,
  275.             (XtArgVal) menulist[i].key_name);
  276.       argcount++;
  277.  
  278.       buttons[i - separators] = XtCreateWidget (menulist[i].name,
  279.                             xmLabelWidgetClass,
  280.                             menu, args, argcount);
  281.  
  282.  
  283.     }
  284.       /*
  285.        * If we got here, the entry must be a submenu. Create a pulldown menu
  286.        * pane and an XmCascadeButton widget. Attach the menu pane and make a
  287.        * recursive call to create the entries in the submenu.
  288.        */
  289.       else
  290.     {
  291.       Widget          sub_menu;
  292.       argcount = 0;
  293.       sub_menu = XmCreatePulldownMenu (menu,
  294.                        menulist[i].sub_menu_title,
  295.                        args, argcount);
  296.  
  297.       argcount = 0;
  298.       XtSetArg (args[argcount], XmNsubMenuId, sub_menu);
  299.       argcount++;
  300.       XtSetArg (args[argcount], XmNmnemonic,
  301.             (XtArgVal) menulist[i].key_name);
  302.       argcount++;
  303.  
  304.       buttons[i - separators] =
  305.         XtCreateWidget (menulist[i].name,
  306.                 xmCascadeButtonWidgetClass,
  307.                 menu, args, argcount);
  308.  
  309.       if ((strcmp (menulist[i].name, help_string) == 0))
  310.         {
  311.           help_widget = buttons[i - separators];
  312.         }
  313.  
  314.       xs_create_menu_buttons (menulist[i].sub_menu_title,
  315.                   sub_menu, menulist[i].sub_menu,
  316.                   menulist[i].n_sub_items,
  317.                   dynamic_callback_data,
  318.                   callback_data);
  319.     }
  320.     }
  321.   /*
  322.    * Manage all button widgets. Menu panes are not managed.
  323.    */
  324.  
  325.   XtManageChildren (buttons, nitems - separators);
  326.  
  327.   argcount = 0;
  328.   XtSetArg (args[argcount], XmNmenuHelpWidget, help_widget);
  329.   argcount++;
  330.   XtSetValues (menu, args, argcount);
  331. }
  332.  
  333. void
  334. create_window_option_menu_bar (title, menu, menulist, nitems, dynamic_callback_data, callback_data,widget_list)
  335.      char           *title;
  336.      Widget          menu;
  337.      xs_window_menu_struct *menulist;
  338.      int             nitems;
  339.      int             dynamic_callback_data;
  340.      struct window_button_callback_struct *callback_data;
  341.      Widget         *widget_list;
  342. {
  343.   int             i;
  344.   WidgetList      buttons;
  345.   int             separators = 0;
  346.  
  347.   Arg             args[32];
  348.   int             argcount = 0;
  349.  
  350.  
  351.   /*
  352.    * Allocate a widget list to hold all button widgets.
  353.    */
  354.  
  355.   buttons = (WidgetList) XtMalloc (nitems * sizeof (Widget));
  356.  
  357.   /*
  358.    * If a title is given, create Label and Separator widgets.
  359.    */
  360.  
  361.   if (title)
  362.     {
  363.  
  364.       argcount = 0;
  365.  
  366.       XtCreateManagedWidget (title, xmLabelWidgetClass, menu,
  367.                  args, argcount);
  368.  
  369.       XtCreateManagedWidget ("separator", xmSeparatorWidgetClass,
  370.                  menu, args, argcount);
  371.     }
  372.  
  373.   /*
  374.    * Create an entry for each item in the menu.
  375.    */
  376.  
  377.   for (i = 0; i < nitems; i++)
  378.     {
  379.  
  380.       /*
  381.        * A NULL name represents a separator.
  382.        */
  383.  
  384.       if (menulist[i].name == NULL)
  385.     {
  386.       XtCreateManagedWidget ("separator",
  387.                  xmSeparatorWidgetClass,
  388.                  menu, args, argcount);
  389.       separators++;        /* Count how many entries aren't buttons */
  390.     }
  391.       /*
  392.        * If there is a name and a callback, create a "normal" menu entry and
  393.        * register the callback function.
  394.        */
  395.       else if (menulist[i].func)
  396.     {
  397. /*
  398.       fprintf (stdout, "Got a functions\n");
  399. */
  400.       argcount = 0;
  401.       XtSetArg (args[argcount], XmNmnemonic,
  402.             (XtArgVal) menulist[i].key_name);
  403.  
  404.       if (menulist[i].indicatorType == 1 )
  405.         {
  406.  
  407.  
  408.               XtSetArg (args[argcount], XmNindicatorType,
  409.                     (XtArgVal) XmONE_OF_MANY);
  410.               argcount++;
  411.                   XtSetArg (args[argcount], XmNselectColor,
  412.                 colorAuxButtonOnBackground.pixel);
  413.                   argcount++;
  414.  
  415.  
  416.  
  417.         }
  418.       else
  419.       if (menulist[i].indicatorType == 2 )
  420.         {
  421.               XtSetArg (args[argcount], XmNindicatorType,
  422.                     (XtArgVal) XmN_OF_MANY);
  423.               argcount++;
  424.  
  425.                   XtSetArg (args[argcount], XmNselectColor,
  426.                 colorAuxButtonOnBackground.pixel);
  427.                   argcount++;
  428.         }
  429.       else
  430.         {
  431.               XtSetArg (args[argcount], XmNindicatorOn, False);
  432.               argcount++;
  433.         }
  434.  
  435.           XtSetArg (args[argcount], XmNbackground,
  436.             colorAuxButtonOffBackground.pixel);
  437.           argcount++;
  438.           XtSetArg (args[argcount], XmNforeground,
  439.             colorAuxButtonOffForeground.pixel);
  440.           argcount++;
  441.  
  442.       if (menulist[i].state & TOGGLE_STIPPLED )
  443.         {
  444.           XtSetArg (args[argcount], XmNsensitive, False);
  445.           argcount++;
  446.           XtSetArg (args[argcount], XmNset, False);
  447.           argcount++;
  448.         }
  449.  
  450.       if (menulist[i].state & TOGGLE_ON )
  451.         {
  452.           XtSetArg (args[argcount], XmNset, True );
  453.           argcount++;
  454.  
  455.         }
  456.  
  457.       buttons[i - separators] = XtCreateWidget (menulist[i].name,
  458.                           xmToggleButtonWidgetClass,
  459.                             menu, args, argcount);
  460. /*
  461.       if (menulist[i].state & TOGGLE_ON)
  462.         {
  463.  
  464.         XmToggleButtonSetState(buttons[i - separators],
  465.                        True,
  466.                        False);
  467.         }
  468. */
  469.  
  470.       if (menulist[i].dynamic_data_index != -1)
  471.         {
  472.  
  473. /*
  474.  * Save the wiget if this is a "VIEW" widget....
  475.  */
  476.           if (menulist[i].dynamic_data_index < dynamic_callback_data)
  477.         {
  478. /*
  479.         fprintf(stdout,"Saving the VIEW widget %d\n",
  480.             menulist[i].dynamic_data_index);
  481. */
  482.         
  483.         widget_list[menulist[i].dynamic_data_index] =
  484.           buttons[i - separators];
  485.         }
  486. /*
  487.           fprintf (stdout, "Going to use dynamic callback at offset %d\n",
  488.                menulist[i].dynamic_data_index);
  489.  
  490.           fprintf (stdout, "sort_mode = %d\n",
  491.            callback_data[menulist[i].dynamic_data_index].sort_mode);
  492.  
  493. */
  494.           XtAddCallback (buttons[i - separators], XmNvalueChangedCallback,
  495.                  menulist[i].func,
  496.                  &callback_data[menulist[i].dynamic_data_index]);
  497.  
  498.         }
  499.       else
  500.         XtAddCallback (buttons[i - separators], XmNvalueChangedCallback,
  501.                menulist[i].func, menulist[i].data);
  502.     }
  503.  
  504.       /*
  505.        * If there is a name, but no callback function, the entry must be a
  506.        * label, unless there is a submenu.
  507.        */
  508.       else if (!menulist[i].sub_menu)
  509.     {
  510.       argcount = 0;
  511.       XtSetArg (args[argcount], XmNmnemonic,
  512.             (XtArgVal) menulist[i].key_name);
  513.       argcount++;
  514.       if (menulist[i].state & TOGGLE_ON)
  515.         {
  516.           XtSetArg (args[argcount], XmNbackground,
  517.             colorAuxButtonOnBackground.pixel);
  518.           argcount++;
  519.           XtSetArg (args[argcount], XmNforeground,
  520.             colorAuxButtonOnForeground.pixel);
  521.           argcount++;
  522.         }
  523.       else
  524.         {
  525.           XtSetArg (args[argcount], XmNbackground,
  526.             colorAuxButtonOffBackground.pixel);
  527.           argcount++;
  528.           XtSetArg (args[argcount], XmNforeground,
  529.             colorAuxButtonOffForeground.pixel);
  530.           argcount++;
  531.         }
  532.  
  533.  
  534.       buttons[i - separators] = XtCreateWidget (menulist[i].name,
  535.                             xmLabelWidgetClass,
  536.                             menu, args, argcount);
  537.  
  538.  
  539.     }
  540.       /*
  541.        * If we got here, the entry must be a submenu. Create a pulldown menu
  542.        * pane and an XmCascadeButton widget. Attach the menu pane and make a
  543.        * recursive call to create the entries in the submenu.
  544.        */
  545.       else
  546.     {
  547.       Widget          sub_menu;
  548.       argcount = 0;
  549.  
  550. /*
  551.       if (menulist[i].state)
  552.         {
  553.           XtSetArg (args[argcount], XmNbackground,
  554.                     colorAuxButtonOnBackground.pixel);
  555.           argcount++;
  556.           XtSetArg (args[argcount], XmNforeground,
  557.                     colorAuxButtonOnForeground.pixel);
  558.           argcount++;
  559.         }
  560.       else
  561.         {
  562.           XtSetArg (args[argcount], XmNbackground,
  563.                     colorAuxButtonOffBackground.pixel);
  564.           argcount++;
  565.           XtSetArg (args[argcount], XmNforeground,
  566.                     colorAuxButtonOffForeground.pixel);
  567.           argcount++;
  568.         }
  569. */
  570.  
  571.       sub_menu = XmCreatePulldownMenu (menu,
  572.                        menulist[i].sub_menu_title,
  573.                        args, argcount);
  574.  
  575.       argcount = 0;
  576.       XtSetArg (args[argcount], XmNsubMenuId, sub_menu);
  577.       argcount++;
  578.       XtSetArg (args[argcount], XmNmnemonic,
  579.             (XtArgVal) menulist[i].key_name);
  580.       argcount++;
  581.       if (menulist[i].state & TOGGLE_ON)
  582.         {
  583.           XtSetArg (args[argcount], XmNbackground,
  584.             colorAuxButtonOnBackground.pixel);
  585.           argcount++;
  586.           XtSetArg (args[argcount], XmNforeground,
  587.             colorAuxButtonOnForeground.pixel);
  588.           argcount++;
  589.         }
  590.       else
  591.         {
  592.           XtSetArg (args[argcount], XmNbackground,
  593.             colorAuxButtonOffBackground.pixel);
  594.           argcount++;
  595.           XtSetArg (args[argcount], XmNforeground,
  596.             colorAuxButtonOffForeground.pixel);
  597.           argcount++;
  598.         }
  599.  
  600.  
  601.       buttons[i - separators] =
  602.         XtCreateWidget (menulist[i].name,
  603.                 xmCascadeButtonWidgetClass,
  604.                 menu, args, argcount);
  605.  
  606.       create_window_option_menu_bar (menulist[i].sub_menu_title,
  607.                      sub_menu, menulist[i].sub_menu,
  608.                      menulist[i].n_sub_items,
  609.                      dynamic_callback_data,
  610.                      callback_data,
  611.                      widget_list);
  612.     }
  613.     }
  614.   /*
  615.    * Manage all button widgets. Menu panes are not managed.
  616.    */
  617.  
  618.   XtManageChildren (buttons, nitems - separators);
  619.  
  620. }
  621.